/**
 * @file accessData.js
 * @Date 2023-11-8, 周三, 16:7
 * @description 文件说明
 *数据访问js
 */

$(function () {
    /******************************************初始化******************************************/
    // tab的index
    let tabIndex = 0;
    // 产品列表数据
    let data = []
    let sourceType = {
        1: '在线数据产品',
        2: '套餐数据产品',
        3: '算法产品',
        4: '离线数据产品',
        5: '应用产品'
    }
    // 重连次数超过三次就不再重连
    let ReconnectNumber = 0;
    // 输出结果的地方
    let result = '.useResult';
    // 当前请求的产品
    let productInfo;
    // 请求产品参数
    let params = {}
    let algCas = layui.layCascader({
        elem: '#algCas',
        clearable: true,
        filterable: true,
        placeholder: "请选择算法",
        // options: data,
        props: {
            multiple: false,//单选
            checkStrictly: true
        },
    });
    $.ajax({
        timeout: 30000,
        url: window.Http + "/getInfo",
        type: 'GET',
        headers: {
            'Authorization': "Bearer " + sessionStorage.getItem('Token')
        },
        success: function (res) {
            if (res.code === 401) {
                layer.alert('未登录，请前往登录界面进行登录', {
                    skin: 'layui-layer-lan'
                    , closeBtn: 0
                    , anim: 1 //动画类型
                }, function () {
                    window.location.href = './login.html';
                });

            }
        }
    })

    // window.ws = new WebSocket(window.monitorWebsocket);
    // ws.onopen = function () {
    //     console.log('连接成功')
    //
    // }
    /******************************************事件处理部分******************************************/
    // 点击中间切换tab展示不同数据
    layui.element.on('tab(dataAccessTab)', function (data) {
        let val = this.innerHTML; //得到当前点击的DOM对象
        tabIndex = data.index;
        console.log('index', tabIndex, typeof tabIndex)
        switch (tabIndex) {
            case 0:
                $(".tab1").addClass("disabledNone");
                $(".tab2").addClass("disabledNone");
                $(".tab3").removeClass("disabledNone");
                $('.accessRightTop').find("p").text("使用结果");
                $(".paramsFile").removeClass("disabledNone");
                $(".testResult").addClass("disabledNone");
                $(".trialResult").addClass("disabledNone");
                $(".useResult").removeClass("disabledNone");
                productListRender(tabIndex)
                // algoList('')
                $("#tabTitle").text("可使用产品列表");
                break;
            case 1:
                $(".tab1").removeClass("disabledNone");
                $(".tab2").addClass("disabledNone");
                $(".tab3").addClass("disabledNone");
                $('.accessRightTop').find("p").text("测试信息");
                $(".paramsFile").removeClass("disabledNone");
                $(".testResult").removeClass("disabledNone");
                $(".trialResult").addClass("disabledNone");
                $(".useResult").addClass("disabledNone");
                productListRender(tabIndex)
                $("#tabTitle").text("可测试产品列表");
                break;
            case 2:
                $(".tab1").addClass("disabledNone");
                $(".tab2").removeClass("disabledNone");
                $(".tab3").addClass("disabledNone");
                $('.accessRightTop').find("p").text("试用结果");

                $(".testResult").addClass("disabledNone");
                $(".trialResult").removeClass("disabledNone");
                $(".paramsFile").removeClass("disabledNone");
                $(".useResult").addClass("disabledNone");
                productListRender(tabIndex)
                $("#tabTitle").text("可试用产品列表");
                break;
            default:
                layer.msg('tab错误')
                break;

        }
        // $(".addParameKeyVal").empty();
        $('.layui-show [name="user"]').val("")
        $('.layui-show [name="expireDate"]').val("")
        $('.layui-show [name="times"]').val("")
        $('.layui-show [name="update"]').val("")
        $('.layui-show [name="useCode"]').val("")
    });

    // 关键字搜索产品
    $('.searchProduct').bind('keypress', function (e) {
        console.log('typeof e.keyCode', typeof e.keyCode)
        if (e.keyCode === 13) {
            // 获取搜索框输入的搜索内容
            let searchKeyword = $(this)[0].value;
            productListRender(tabIndex, searchKeyword)
        }
    })

    // 点击左侧产品展示数据
    $('.accessUl').delegate('a', 'click', function (e) {
        e.preventDefault();
        $('.accessUl a').removeClass("active")
        $(this).addClass("active");
        let currentId = $(this).attr("dataId");
        params.productId = Number(currentId);
        // parame.sourceId = $(this).attr("sourceId");
        data.forEach((item, index) => {
            if (tabIndex === 0) {
                // console.log('productInfo', productInfo)
                if (item.dataProductVo && item.dataProductVo.id == currentId) {
                    productInfo = item;
                    console.log('productInfo', productInfo)
                    $('.layui-show [name="user"]').val(item.createBy || item.dataProductVo.createBy);
                    // console.log('item.sourceType||item.dataProductVo.sourceType', item.sourceType||item.dataProductVo.sourceType)
                    let sourceTypeText = sourceType[item.sourceType || item.dataProductVo.sourceType]
                    $('.layui-show [name="sourceType"]').val(sourceTypeText || '无');
                    if (sourceTypeText === '在线数据产品' || sourceTypeText === '套餐数据产品' || sourceTypeText === '离线数据产品') {
                        $('.algCas').removeClass('disabledNone')
                    } else {
                        $('.algCas').addClass('disabledNone')
                    }
                    // $('.layui-show [name="expireDate"]').val(item.canUseTime || "—");
                    if (item.canUseNumber) {
                        $('.layui-show [name="canUseNumber"]').parents(".col").removeClass("disabledNone");
                        $('.layui-show [name="canUseNumber"]').val(item.canUseNumber);
                    }
                    if (item.canUseRecords) {
                        $('.layui-show [name="canUseRecords"]').parents(".col").removeClass("disabledNone");
                        $('.layui-show [name="canUseRecords"]').val(item.canUseRecords);
                    }
                    if (item.canUseTime) {
                        $('.layui-show [name="canUseTime"]').parents(".col").removeClass("disabledNone");
                        $('.layui-show [name="canUseTime"]').val(item.canUseTime);
                    }
                    if (item.canUseNumberLocal) {
                        $('.layui-show [name="canUseNumberLocal"]').parents(".col").removeClass("disabledNone");
                        $('.layui-show [name="canUseNumberLocal"]').val(item.canUseNumberLocal);
                    }
                    if (item.canUseTimeLocal) {
                        $('.layui-show [name="canUseTimeLocal"]').parents(".col").removeClass("disabledNone");
                        $('.layui-show [name="canUseTimeLocal"]').val(item.canUseTimeLocal);
                    }
                }

            } else if (tabIndex === 1) {

                if (item.id === Number(currentId)) {
                    productInfo = item;
                    console.log('productInfo', productInfo)
                    $('.layui-show [name="user"]').val(item.createBy || item.dataProductVo.createBy);
                    $('.layui-show [name="update"]').val(`${item.updateTime ? item.updateTime.slice(0, 10) : '--'}`);
                    // LoopAddParames(item.dataproductParamList);
                }

            } else if (tabIndex === 2) {
                productInfo = item;
                $('.layui-show [name="user"]').val(item.dataProductVo.createBy);
                // console.log('item.sourceType||item.dataProductVo.sourceType', item.sourceType||item.dataProductVo.sourceType)
                let sourceTypeText = sourceType[item.sourceType || item.dataProductVo.sourceType]
                $('.layui-show [name="sourceType"]').val(sourceTypeText || '无');
                if (sourceTypeText === '在线数据产品' || sourceTypeText === '套餐数据产品' || sourceTypeText === '离线数据产品') {
                    $('.algCas').removeClass('disabledNone')
                } else {
                    $('.algCas').addClass('disabledNone')
                }
            }

        })
    })
    // 提交测试
    $('.accessbot [type="submit"]').on('click', function (e) {
        e.preventDefault();
        params.type = Number(tabIndex);
        switch (tabIndex) {
            case 0:
                result = '.useResult';
                break;
            case 1:
                result = '.testResult';
                break;
            case 2:
                result = '.trialResult';
                break;
            default:
                console.log('tabindex 错误');
                break;
        }
        $(result).empty()
        $(result).append('<p>开始请求产品</p>')
        execute(params)
            .then(res => {
                $(result).append('<p>请求产品成功</p>')
                // 判断是在线产品还是离线产品
                const ProductType = productInfo?.dataProductVo?.sourceType === 4 ? 'off' : 'on'
                // 使用产品
                if (params.type === 0) {
                    // 判断返回参数
                    console.log(res)
                    if (res.data.Payload && res.data.Payload.Result && res.data.Payload.Result.length > 0) {
                        console.log(productInfo.sharedType)
                        console.log(productInfo.sharedType > 0)
                        // 判断产品是否需要确权授权和是否加密
                        if (productInfo.sharedType > 0 || productInfo.isLocked !== -1) {
                            const {
                                Buyer,
                                Seller,
                                AsymmetricPwdType,
                                SellerKey,
                                SellerCaTimeStamp,
                                BuyerCaTimeStamp
                            } = res.data.Payload;
                            const { ProductName, ProductID, Message, Pwd } = res.data.Payload.Result[0];
                            //判断参数是否返回
                            if (Buyer && Seller && AsymmetricPwdType && SellerKey && BuyerCaTimeStamp && ProductName && ProductID && Message && (Pwd !== '')) {
                                // 判断url格式是否正确
                                if (Message.startsWith("Url:")) {
                                    const url = Message.slice(4)
                                    console.log('url', url)
                                    let calcParams = {
                                        Cmd: "Calc",
                                        Payload: {
                                            ProductID,//产品id
                                            ProductName,
                                            Buyer,
                                            Seller,
                                            HaveData: false,//暂时写死表示都放在文件服务器上面
                                            ProductPosition: url,
                                            CipherSymmetricKey: Pwd,
                                            CertificateTypeAlgorithmType: AsymmetricPwdType.toLocaleLowerCase(),
                                            // SymmetricKeyAlgorithmType: SymmetricPwdType.toLocaleLowerCase(),
                                            ProductType,//"on"代表在线产品，“off”代表离线产品
                                            SellerKey,
                                            SellerCaTimeStamp,
                                            BuyerCaTimeStamp,
                                            NeedConfirmAndGrantPermission: productInfo.sharedType === 3,//授权确权
                                            NeedConfirmPermission: productInfo.sharedType === 2,//确权
                                            NeedGrantPermission: productInfo.sharedType === 1,//授权
                                            NeedDecrypt: productInfo.isLocked !== -1
                                        }
                                    }
                                    console.log('calcParams', calcParams)
                                    $(result).append('<p>开始连接数据监管程序请求解密</p>')
                                    CalcSend(calcParams)
                                } else {
                                    $(result).append('<p>请求产品返回url错误</p>')
                                }
                            } else {
                                $(result).append('<p>请求产品返回参数错误</p>')
                            }
                        } else {
                            $(result).append('<p>产品未加密，不需要解密</p>')
                            const { Message } = res.data.Payload.Result[0];
                            if (Message) {
                                console.log('Message', Message)
                                const url = Message.slice(4);
                                let useParams = {
                                    Cmd: 'Use',
                                    ProductUrl: url,
                                    AlgoName: null
                                }
                                let AlgoName = algCas.getCheckedValues()
                                console.log('AlgoName', AlgoName)
                                if (algCas.getCheckedValues()) {
                                    useParams.AlgoName = AlgoName
                                    $(result).append('<p>该产品需要调用算法,请求监管程序调用</p>')
                                    useSend(useParams)
                                } else {
                                    $(result).append('<p>该产品无需调用算法</p>')
                                    $(result).append('<p>产品开始下载</p>')
                                    console.log('url', url)
                                    // window.location.href=url;
                                    // 产品是json还是png
                                    const productTypePNG = productInfo.dataProductVo.productType;
                                    console.log('ProductType', ProductType)
                                    showProduct(productTypePNG, url, ProductType)
                                }
                            } else {
                                $(result).append('<p>产品url获取失败</p>')
                            }
                        }
                    } else {
                        $(result).append('<p>请求产品返回参数错误</p>')
                    }
                } else if (params.type === 1) {//测试产品
                    $(result).append('<p>测试通过</p>')
                } else if (params.type === 2) {//试用产品
                    // 判断返回参数
                    if (res.data.Payload && res.data.Payload.Result && res.data.Payload.Result.length > 0) {
                        if (res.data.Payload && res.data.Payload.Result && res.data.Payload.Result.length > 0) {
                            if (false) {
                                const {
                                    Buyer,
                                    Seller,
                                    AsymmetricPwdType,
                                    SellerKey,
                                    SellerCaTimeStamp,
                                    BuyerCaTimeStamp
                                } = res.data.Payload;
                                $(result).append('<p>产品未加密，不需要解密</p>')
                                const { ProductName, ProductID, Message, Pwd } = res.data.Payload.Result[0];
                                //判断参数是否返回
                                if (Buyer && Seller && ProductName && ProductID && Message && (Pwd !== '')) {
                                    // 判断url格式是否正确
                                    if (Message.startsWith("Url:")) {
                                        const url = Message.slice(4)
                                        console.log('url', url)
                                        let calcParams = {
                                            Cmd: "Calc",
                                            Payload: {
                                                ProductID,//产品id
                                                ProductName,
                                                Buyer,
                                                Seller,
                                                HaveData: false,//暂时写死表示都放在文件服务器上面
                                                ProductPosition: url,
                                                CipherSymmetricKey: Pwd,
                                                CertificateTypeAlgorithmType: AsymmetricPwdType.toLocaleLowerCase(),
                                                // SymmetricKeyAlgorithmType: SymmetricPwdType.toLocaleLowerCase(),
                                                ProductType,//"on"代表在线产品，“off”代表离线产品
                                                SellerKey,
                                                SellerCaTimeStamp,
                                                BuyerCaTimeStamp,
                                                NeedConfirmAndGrantPermission: productInfo.sharedType === 3,//授权确权
                                                NeedConfirmPermission: productInfo.sharedType === 2,//确权
                                                NeedGrantPermission: productInfo.sharedType === 1,//授权
                                                NeedDecrypt: productInfo.isLocked !== -1
                                            }
                                        }
                                        console.log('calcParams', calcParams)
                                        $(result).append('<p>开始连接数据监管程序请求解密</p>')
                                        CalcSend(calcParams)
                                    } else {
                                        $(result).append('<p>请求产品返回url错误</p>')
                                    }
                                } else {
                                    $(result).append('<p>请求产品返回参数错误</p>')
                                }
                            } else {
                                $(result).append('<p>产品未加密，不需要解密</p>')
                                const { Message } = res.data.Payload.Result[0];
                                if (Message) {
                                    console.log('Message', Message)
                                    const url = Message.slice(4);
                                    let useParams = {
                                        Cmd: 'Use',
                                        ProductUrl: url,
                                        AlgoName: null
                                    }
                                    let AlgoName = algCas.getCheckedValues()
                                    console.log('AlgoName', AlgoName)
                                    if (algCas.getCheckedValues()) {
                                        useParams.AlgoName = AlgoName
                                        $(result).append('<p>该产品需要调用算法,请求监管程序调用</p>')
                                        useSend(useParams)
                                    } else {
                                        $(result).append('<p>该产品无需调用算法</p>')
                                        $(result).append('<p>产品开始下载</p>')
                                        console.log('url', url)
                                        // window.location.href=url;
                                        // 产品是json还是png
                                        const productTypePNG = productInfo.dataProductVo.productType;
                                        console.log('ProductType', ProductType)
                                        showProduct(productTypePNG, url, ProductType)
                                    }
                                } else {
                                    $(result).append('<p>产品url获取失败</p>')
                                }
                            }
                            // if (Message && Message.startsWith("Url:")) {
                            //     const url = Message.slice(4)
                            //     console.log('url', url)
                            //     window.location.href = url;
                            //     // 产品是json还是png
                            //     const productTypePNG = productInfo?.dataProductVo?.productType;
                            //     console.log('productInfo', productInfo)
                            //     showProduct(productTypePNG, url, ProductType)
                            // } else {
                            //     $(result).append('<p>请求产品返回url错误</p>')
                            // }
                        }
                    } else {
                        $(result).append('<p>请求产品失败</p>')
                    }
                } else {
                    layer.msg('选项index错误')
                }
                // if (window.ws.readyState === WebSocket.OPEN) {
                //     CalcSend(calcParams)
                // } else {
                //     // 重连
                //     window.ws = new WebSocket(window.monitorWebsocket);
                //     window.ws.onopen = function () {
                //         CalcSend(calcParams)
                //     }
                // }
                // EngineStatus()
                //         .then(()=>{
                //              $(result).append('<p>开始请求数据监管程序解密</p>')
                //              Calc(calcParams)
                //                  .then(data=>{
                //                      $(result).append('<p>解密成功开始下载</p>')
                //                      if (data&&data.Payload&&data.Payload.Url){
                //                          window.location.href = data.Payload.Url;
                //                      }else {
                //                          $(result).append('<p>解密后文件url获取失败</p>')
                //                      }
                //                  })
                //                  .catch(()=>{
                //                      $(result).append(`<p>请求数据监管程序解密失败,失败原因:</p>`)
                //                  })
                //         })
                //         .catch(()=>{
                //             layer.open({
                //                 content:'连接监管程序失败,是否安装数据监管程序？',
                //                 btn: ['安装', '不安装'],
                //                 yes:function (index,layero) {
                //
                //                     monitorDownload()
                //                         .then((data)=>{
                //                             layer.close(index1);
                //                             window.location.href=data.Data;
                //                         })
                //                         .catch(()=>{
                //                             layer.close(index1);
                //                             layer.msg('请求下载失败')
                //                         })
                //                     $(result).append(`<p>连接监管程序失败,开始下载监管程序:</p>`)
                //                     setTimeout(function () {
                //                         layer.close(index);
                //                         // window.location.href = './index.html';
                //                     },1000)
                //                 },
                //                 btn2: function (index,layero){
                //                     layer.close(index);
                //                     $(result).append(`<p>取消安装监管程序，使用产品结束</p>`)
                //                     // window.location.href = './index.html';
                //                 }
                //             })
                //         })
            })
            .catch((err) => {
                console.log(`err:${err}`)
                $(result).append('<p>请求产品失败execute</p>')
                // layer.msg(res?.msg || '请求产品失败execute')
            })
    })

    //TODO 上传参数文件

    /******************************************功能函数部分******************************************/

    /**
     * @description:函数描述 请求使用产品列表
     * @return {Promise} 请求的结果
     * @param searchKeyword {String} 关键字
     */
    function productUseListReq(searchKeyword = '') {
        return new Promise(function (resolve, reject) {
            $.ajax({
                timeout: 30000,
                url: window.Http + "/dataProduct/prove/list",
                type: 'GET',
                headers: {
                    'Authorization': "Bearer " + sessionStorage.getItem('Token')
                },
                data: { userId: sessionStorage.getItem('UserId'), keyword: searchKeyword, canUse: 1 },
                success: function (res) {
                    if (res.code === 200) {
                        resolve(res)
                    } else {
                        reject(new Error('请求使用产品列表失败'))
                        layer.msg(res.msg)
                    }
                }
            })
        })
    }

    /**
     * @description:函数描述 请求测试产品列表
     * @return {Promise} 请求的结果
     * @param searchKeyword {String} 关键字
     */
    function productTestListReq(searchKeyword = '') {
        return new Promise(function (resolve, reject) {
            $.ajax({
                timeout: 30000,
                url: window.Http + "/dataProduct/list",
                type: 'GET',
                headers: {
                    'Authorization': "Bearer " + sessionStorage.getItem('Token')
                },
                data: { status: 0, keyword: searchKeyword, ownUserId: sessionStorage.getItem('UserId') },
                success: function (res) {
                    if (res.code === 200) {
                        resolve(res)
                    } else {
                        reject(new Error('请求测试产品列表失败'))
                        layer.msg(res.msg)
                    }
                }
            })
        })
    }

    /**
     * @description:函数描述 请求试用产品列表
     * @return {Promise} 请求的结果
     * @param searchKeyword {String} 关键字
     */
    function productTryListReq(searchKeyword = '') {
        return new Promise(function (resolve, reject) {
            $.ajax({
                url: window.Http + "/tryInfo/list/all",
                type: 'GET',
                headers: {
                    'Authorization': "Bearer " + sessionStorage.getItem('Token')
                },
                data: { userId: sessionStorage.getItem('UserId'), keyword: searchKeyword },
                success: function (res) {
                    if (res.code === 200) {
                        resolve(res)
                    } else {
                        reject(new Error('请求测试产品列表失败'))
                        layer.msg(res.msg)
                    }
                }
            })
        })
    }

    /**
     * @description:函数描述 渲染产品列表
     * @return 返回值
     * @param type {Number} 0-使用 1-测试 2-试用
     * @param keyword
     */
    function productListRender(type = 0, keyword = '') {
        let index = layer.load(1);
        console.log('type', type)
        switch (type) {
            case 0:
                productUseListReq(keyword).then(res => {
                    data = res.rows;
                    layer.close(index);
                    $(".accessUl ul").empty();
                    if (data && data.length > 0) {
                        let html = "";
                        data.forEach(function (val, index) {
                            if (val.dataProductVo) {
                                html += `<li><a dataId="` + val.dataProductVo.id + `" sourceId="` + val.dataProductVo.sourceId + `">` + val.productName + `</a> </li>`
                            } else {
                                html += `<li><a>` + val.productName + `(已下架)</a> </li>`
                            }
                        })
                        $(".accessUl ul").append(html);
                    } else {
                        let html = `<li><a href="" class="product">暂无产品</a> </li>`;
                        $(".accessUl ul").append(html);
                    }
                })
                break;
            case 1:
                productTestListReq(keyword).then(res => {
                    data = res.rows;
                    layer.close(index);
                    $(".accessUl ul").empty();
                    if (data && data.length > 0) {
                        let html = "";
                        data.forEach(function (val, index) {
                            html += `<li><a dataId="` + val.id + `" sourceId="` + val.sourceId + `">` + val.productName + `</a> </li>`
                        })
                        $(".accessUl ul").append(html);
                    } else {
                        let html = `<li><a href="" class="product">暂无产品</a> </li>`;
                        $(".accessUl ul").append(html);
                    }
                })
                break;
            case 2:
                productTryListReq(keyword).then(res => {
                    data = res.data
                    layer.close(index);
                    $(".accessUl ul").empty();
                    if (data && data.length > 0) {
                        let html = "";
                        data.forEach(function (val, index) {
                            if (val.dataProductVo) {
                                html += `<li><a dataId="` + val.dataProductVo.id + `" sourceId="` + val.dataProductVo.sourceId + `">` + val.productName + `</a> </li>`
                            } else {
                                html += `<li><a>` + val.productName + `(已下架)</a> </li>`
                            }
                        })
                        $(".accessUl ul").append(html);
                    } else {
                        let html = `<li><a href="" class="product">暂无产品</a> </li>`;
                        $(".accessUl ul").append(html);
                    }
                })
                break;
            default:
                layer.msg('type错误')
                break;
        }
    }

    /**
     * @description:函数描述 请求产品 ->核心服务器
     * @return {Promise}
     * @param params
     */
    function execute(params) {
        return new Promise(function (resolve, reject) {
            $.ajax({
                url: window.Http + '/dataProduct/execute',
                type: 'POST',
                headers: {
                    'Authorization': "Bearer " + sessionStorage.getItem('Token'),
                    'content-Type': "application/json;charset=utf-8"
                },
                data: JSON.stringify(params),
                success: function (res) {
                    if (res.code === 200 && res.data.RetCode === 0) {
                        resolve(res)
                    } else {
                        console.log('失败',)
                        $(result).append('<p>请求产品失败execute</p>')
                        reject(res)
                        // layer.msg(res.data.ErrorMsg)
                    }
                },
                error: function () {
                    console.log('失败',)
                    reject(new Error('请求产品失败execute'))
                }
            })
        })
    }

    /**
     * @description:函数描述 请求解密
     * @return 返回值
     * @param calcParams {Object}
     */
    function CalcSend(calcParams) {
        console.log('productInfo', productInfo)
        console.log('calcParams', calcParams)
        console.log('calcParams.ProductType', calcParams.ProductType)
        if (socket.readyState === WebSocket.OPEN) {
            socket.send(JSON.stringify(calcParams))
            socket.onmessage = function (MessageEvent) {
                console.log('MessageEvent.data', MessageEvent.data)
                if (MessageEvent.data) {
                    const resData = JSON.parse(MessageEvent.data);
                    console.log('resData', resData)
                    if (resData.Cmd === 'CalcRet' && resData.RetCode === 200) {
                        if (resData && resData.Payload && resData.Payload.Url) {
                            const url = resData.Payload.Url;
                            if (algCas.getCheckedValues()) {
                                let useParams = {
                                    Cmd: 'Use',
                                    ProductUrl: url,
                                    AlgoName: null
                                }
                                let AlgoName = algCas.getCheckedValues()
                                $(result).append('<p>该产品需要调用算法,请求监管程序调用</p>')
                                useParams.AlgoName = AlgoName
                                useSend(useParams)
                            } else {
                                $(result).append('<p>该产品无需调用算法</p>')
                                $(result).append('<p>解密成功开始下载</p>')
                                window.location.href = url;
                                const productType = productInfo.dataProductVo.productType;
                                // const productType='png';
                                const onOrOff = calcParams.Payload.ProductType//产品是在线还是离线on或者off
                                console.log('onOrOff', onOrOff)
                                showProduct(productType, url, onOrOff)
                            }
                        } else {
                            $(result).append('<p>解密后文件url获取失败</p>')
                        }
                    } else {
                        $(result).append(` <p>请求监管程序失败:${resData?.Msg}</p>`)
                    }
                }
            }
        } else {
            console.error('WebSocket连接未打开');
            // 可以尝试重新连接或者进行其他处理
            ReconnectNumber++;
            connectWebSocket()
        }
    }

    /**
     * @description:函数描述 向监管程序请求算法列表
     * @param algoListParams
     */
    function algoListSend(algoListParams) {
        if (socket.readyState === WebSocket.OPEN) {
            console.log('发送消息algoListParams', algoListParams)
            socket.send(JSON.stringify(algoListParams));
            socket.onmessage = function (MessageEvent) {
                const resData = JSON.parse(MessageEvent.data);
                console.log('resData', resData)
                if (resData.Code === 200 && resData.Cmd === 'AlgoListRet') {
                    const algoList = JSON.parse(resData.Data)
                    console.log('resData.Data', resData.Data)
                    console.log('algoList', algoList)
                    algCas.setOptions(dataFormat(algoList, 'Name', 'Name'))
                } else {
                    $(result).append(` <p>请求监管程序失败:${resData?.Msg}</p>`)
                }
            }
        } else {
            console.error('WebSocket连接未打开');
            // 可以尝试重新连接或者进行其他处理
            ReconnectNumber++;
            connectWebSocket()
        }
    }

    /**
     * @description:展示产品
     * @return 返回值
     * @param productType 产品类型 png，json
     * @param url {String} 产品url
     *  @param onOrOff 产品是在线还是离线
     */
    function showProduct(productType, url, onOrOff) {
        if (productType) {
            console.log('产品类型', productType, onOrOff)
            $(result).append('<p>结果展示</p>')
            if (productType === 'png' || productType === 'jpg' || productType === 'jpeg') {
                // let imageSrc=url.split('?',2)[0].replace(".enc",`.${productType}`);
                // console.log('imageSrc', imageSrc)
                // let resultHTML=`
                // <img alt="图片" src=${imageSrc}>
                // `
                // $(result).append(resultHTML)

                fetch(url)
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('Network response was not ok');
                        }
                        return response.blob();
                    })
                    .then(blob => {
                        const img = document.createElement('img');
                        img.src = URL.createObjectURL(blob);
                        $(result).append(img); // 添加到页面中的合适位置
                    })
                    .catch(error => {
                        console.error('There has been a problem with your fetch operation:', error);
                        $(result).append(` <p>解析url失败,原因：${error}</p>`)
                    });

            } else if (productType === 'json') {
                fetch(url)
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('Network response was not ok');
                        }
                        return response.blob();
                    })
                    .then(blob => {
                        blob.text().then(text => {
                            if (onOrOff === 'on') {
                                jsonTableShow(text)
                            }
                            // 离线产品使用jquery.json-viewer库展示
                            else if (onOrOff === 'off') {
                                const resultHTML = `<pre id="json-renderer"></pre>`
                                $(result).append(resultHTML)
                                try {
                                    const json = JSON.parse(text);
                                    $('#json-renderer').jsonViewer(json);
                                } catch (e) {
                                    console.log(e)
                                    layer.msg('JSON格式错误')
                                    $(result).append(` <p>JSON格式错误：${e}</p>`)
                                }
                                // const data = {
                                //     "foobar": "foobaz"
                                // };
                                // $('#json-renderer').jsonViewer(text);
                            } else {
                                $(result).append('<p>当前产品类型不支持展示</p>')
                            }

                            // const  jsonTable=layui.table.render(jsonObj)
                            // console.log(json); // 处理 JSON 数据，可以根据需求进行操作
                        });
                    })
                    .catch(error => {
                        console.error('There has been a problem with your fetch operation:', error);
                        $(result).append(` <p>解析url失败,原因：${error}</p>`)
                    });
            } else {
                $(result).append('<p>当前产品类型不支持展示</p>')
            }

        } else {
            $(result).append('<p>产品类型缺失，无法展示产品结果</p>')
        }
    }

    /**
     * @description:函数描述 请求监管程序使用算法
     * @return 返回值
     * @param useParams
     */
    function useSend(useParams) {
        if (socket.readyState === WebSocket.OPEN) {
            console.log('useParams', useParams)
            socket.send(JSON.stringify(useParams));
            socket.onmessage = function (MessageEvent) {
                console.log('MessageEvent.data', MessageEvent.data)
                if (MessageEvent.data) {
                    const resData = JSON.parse(MessageEvent.data);
                    console.log('resData', resData)
                    if (resData.Cmd === "UseRet" && resData.Code === 200) {
                        $(result).append('<p>调用算法使用产品成功</p>')
                        if (resData.Data.HaveData) {
                            if (resData.Data.Type === 'json' || resData.Data.Type === "JSON") {
                                jsonTableShow(resData.Data.Data)
                            } else {
                                $(result).append(`<p>结果:\n ${resData.Data.Data}</p>`)
                            }
                        } else {
                            $(result).append('<p>开始下载结果</p>')
                            window.location.href = resData.Data.Url;
                        }
                    } else {
                        $(result).append(`<p>请求监管程序调用算法失败:${resData?.Msg}</p>`)
                    }
                }
            }
        } else {
            console.log('连接失败')
        }
    }

    /**
     * 函数描述
     * @return 返回值
     * @example
     * @param data
     */
    function jsonTableShow(data) {
        const json = JSON.parse(data);
        let resultHTML = `
                                              <table class="layui-table" id="jsonTable" lay-filter="jsonTable">
                                             `
        $(result).append(resultHTML)
        let jsonObj = {
            elem: '#jsonTable'
            , data: []
            , page: true //开启分页
            , cols: [[ //表头
                { type: 'numbers', title: '序号', width: 60 }
            ]]
        }
        if (json.Fields) {
            json.Fields.forEach((item) => {
                jsonObj.cols[0].push({ field: item, title: item })
            })


            let rows = []
            for (let i = 0; i < json.Rows.length; i++) {
                let obj = {};
                for (let j = 0; j < json.Fields.length; j++) {
                    obj[json.Fields[j]] = json.Rows[i][j];
                }
                rows.push(obj);
            }
            console.log('rows', rows)
            jsonObj.data = rows;
            console.log('jsonObj', jsonObj)
            const jsonTable = layui.table.render(jsonObj);
            // jsonTable.reload({data:rows})
        } else {
            $(result).append(` <p>解析json失败</p>`)
        }
    }

    // 数据转换成级联列表需要的样式
    // data:原始数组，value:绑定的值（id），label：标签显示值，返回正确格式数组
    function dataFormat(data, value, label) {
        let arr = []
        data.forEach(function (item, index) {
            arr[index] = { value: '', label: '' }
            arr[index].value = data[index][value];
            arr[index].label = data[index][label]
        })
        return arr;
    }


    /**
     * @description:websocket连接
     * @param:{type} 参数说明
     * @return 返回值
     */
    // websocket 连接
    let socket = null;
    let messageTimeout = null;

    function connectWebSocket() {
        socket = new WebSocket(window.monitorWebsocket);

        socket.addEventListener('open', function (event) {
            console.log('WebSocket连接已打开');
            // 连接成功就获取算法
            let algoListParams = {
                Cmd: "AlgoList"
            }
            algoListSend(algoListParams)
        });

        socket.addEventListener('close', function (event) {
            console.log('WebSocket连接已关闭');
            layer.msg('WebSocket连接已关闭')
            // 重新连接（可根据需求设置延迟）
            ReconnectNumber++;
            if ((ReconnectNumber <= 3)) {
                setTimeout(connectWebSocket, 3000);
            } else {
                layer.msg('重连次数超过三次都连接失败，不再重连，如果需要重连，请刷新页面')
            }
        });

        socket.addEventListener('error', function (error) {
            console.error('WebSocket连接发生错误:', error);
            layer.msg('WebSocket连接发生错误')
        });

        socket.addEventListener('message', function (event) {
            console.log('收到消息:', event.data);
            // 在收到消息后清除超时计时器
            clearTimeout(messageTimeout);
        });
    }

    productListRender(0)

    // 连接监管程序
    connectWebSocket()
})